Instance 0

Class410.getExistingFileContents()#0{
            if (fileEncoding == null) {
                isr = new InputStreamReader(fis);
            } else {
                isr = new InputStreamReader(fis, fileEncoding);
            }
            BufferedReader br = new BufferedReader(isr);
            int returnedBytes = br.read(buffer);
            while (returnedBytes != -1) {
                sb.append(buffer, 0, returnedBytes);
                returnedBytes = br.read(buffer);
            }
            br.close();
}


Instance 1

Class370.getSource(IFile file)#1{
      in= file.getContents();
        if (encoding != null) {
            br= new BufferedReader(new InputStreamReader(in, encoding));  
        } else {
            br= new BufferedReader(new InputStreamReader(in));
        }
      while ((read= br.read()) != -1) {
        sb.append((char) read);
      }
      br.close();
}


Instance 2

Class570.readText(InputStream is,String charset)#0{
    if (charset==null||charset.isEmpty()||charset.equalsIgnoreCase("tika")) {
      reader = new BufferedReader(new InputStreamReader(is));
    } else {
      reader = new BufferedReader(new InputStreamReader(is,charset));
    }
    while ((c = reader.
}


Instance 3

Class190.getFileContent(String filePath)#0{
                in = new BufferedReader(new InputStreamReader(getClass().getClassLoader().getResourceAsStream(filePath)));
                int ch = in.read();
                while (ch > -1) {
                    sb.append((char)ch);
                    ch = in.read();
                }
}


Instance 4

Class460.main(String[] args)#0{
        BufferedReader r = new BufferedReader(new StringReader("12"));
        r.read();
        r.mark(2);
        while (r.read() != -1);
        r.reset();
        while (r.read() != -1) {
            count++;
        }
}


Instance 5

Class660.getGrammarFileLines(String filename)#0{
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), "UTF-8"));
            int c = reader.read();
            while (c != -1) {
                sb.append((char)c);
                c = reader.read();
            }
}


Instance 6

Class230.getStreamText(InputStream stream)#0{
        InputStreamReader isr = new InputStreamReader(stream);
        BufferedReader reader = new BufferedReader(isr);
        int numRead = reader.read(buf);
        while (numRead != -1)
        {
          // output temp buffer to output buffer
          sw.write(buf, 0, numRead);

          // fill buffer
          numRead = reader.read(buf);
        }
        if (stream != null)
        {
          stream.close();
        }
}


Instance 7

Class450.getResourceText(String name)#2{
        InputStreamReader isr = new InputStreamReader(stream);
        BufferedReader reader = new BufferedReader(isr);
        int numRead = reader.read(buf);
        while (numRead != -1)
        {
          // output temp buffer to output buffer
          sw.write(buf, 0, numRead);

          // fill buffer
          numRead = reader.read(buf);
        }
        if (stream != null)
        {
          stream.close();
        }
}


Instance 8

Class190.execCmd(File wd,String[] cmdWithArguments,StringBuffer out)#3{
    Reader reader = new InputStreamReader(p.getInputStream());
    BufferedReader input = new BufferedReader(reader);
    while ((readChar = input.read()) != -1) {
      out.append((char) readChar);
    }
    input.close();
}


Instance 9

Class540.execMysqlCmd(String cmd,String sourceFile,boolean includeDB)#4{
      Reader reader = new InputStreamReader(p.getInputStream());
      BufferedReader input = new BufferedReader(reader);
      while ((readChar = input.read()) != -1) {
        out.append((char) readChar);
      }
      input.close();
}


Instance 10

Class190.execCmd(File wd,String[] cmdWithArguments,StringBuffer out)#4{
    reader = new InputStreamReader(p.getErrorStream());
    input = new BufferedReader(reader);
    while ((readChar = input.read()) != -1) {
      out.append((char) readChar);
    }
    input.close();
}


Instance 11

Class540.execMysqlCmd(String cmd,String sourceFile,boolean includeDB)#6{
      reader = new InputStreamReader(p.getErrorStream());
      input = new BufferedReader(reader);
      while ((readChar = input.read()) != -1) {
        out.append((char) readChar);
      }
      input.close();
}


Instance 12

Class590.readStream(final InputStream is)#0{
      final BufferedReader reader = new BufferedReader(
          new InputStreamReader(is));
      while ((numRead = reader.read(chars)) > -1) {
        sb.append(new String(chars, 0, numRead));
      }
      reader.close();
}


Instance 13

Class530.getOutput(int limitBytes)#0{
      BufferedReader stdout = new BufferedReader(new InputStreamReader(
          objdump.getInputStream()));
      while ((len = stdout.read(buf, 0, buf.length)) != -1) {
        if (limitBytes > 0 && buffer.length() + len >= limitBytes) {
          buffer.append(buf, 0, Math.min(len, limitBytes - buffer.length()));
          break;
        }
        buffer.append(buf, 0, len);
      }
        stdout.close();
      return buffer.toString().getBytes();
}


Instance 14

Class550.toString(Reader reader)#0{
                BufferedReader br = (reader instanceof BufferedReader) ? (BufferedReader) reader
                        : new BufferedReader(reader, BUFFER_SIZE);
                int charsRead = br.read(buffer);
                while (charsRead != -1) {
                    sb.append(buffer, 0, charsRead);
                    charsRead = br.read(buffer);
                }
                br.close();
}


Instance 15

Class260.getOutput()#2{
    BufferedReader stdout = new BufferedReader(new InputStreamReader(objdump.getInputStream()));
    while ((len = stdout.read(buf, 0, buf.length)) != -1) {
      buffer.append(buf, 0, len);
    }
    stdout.close();
}


Instance 16

Class200.read(String filename)#1{
    final BufferedReader reader = new BufferedReader(new InputStreamReader(this.getClass().getResourceAsStream(filename)));
    while ((numRead = reader.read(buf)) != -1) {
      final String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 17

Class370.read(InputStream is)#0{
      BufferedReader inFile = new BufferedReader(new InputStreamReader(is));
      while ((len = inFile.read(buff)) >= 0)
        strb.append(buff, 0, len);
      inFile.close();
}


Instance 18

Class250.readResource(String resource)#0{
            InputStream input = Thread.currentThread().getContextClassLoader().getResourceAsStream(resource);
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                fileData.append(readData);
            }
            reader.close();
}


Instance 19

Class320.loadTheaterData()#1{
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                DummyDataProvider.class.getResourceAsStream("cities.txt")));
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                fileData.append(readData);
                buf = new char[1024];
            }
            reader.close();
}


Instance 20

Class660.readFileAsString()#0{
      reader = new BufferedReader(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream(this.scriptFilePath)));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
      }
      reader.close();
}


Instance 21

Class610.fileToString(String path)#1{
      BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
      while((c = reader.read(buffer, 0, buffer.length)) != -1)
      {
        sBuffer.append(buffer, 0, c);
      }
      reader.close();
}


Instance 22

Class30.readFile(InputStream in)#3{
    final BufferedReader br = new BufferedReader(new InputStreamReader(in));
    while ((cnt = br.read(buffer, 0, buffer.length)) > -1) {
      sBuffer.append(buffer, 0, cnt);
    }
    br.close();
}


Instance 23

Class540.readStreamAsString(final InputStream iStream)#0{
    final BufferedReader reader = new BufferedReader(new InputStreamReader(iStream));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);

        if (fileData.length() == 0 && readData.startsWith(UTF8_BOM))
          // SKIP UTF-8 BOM IF ANY
          readData = readData.substring(1);

        fileData.append(readData);
      }
      reader.close();
}


Instance 24

Class110.getInputStreamAsString(InputStream stream)#0{
      br = new BufferedReader(new InputStreamReader(stream));
      while ((len = br.read(cbuf)) > 0) {
        sb.append(cbuf, 0, len);
      }
      if(br != null) br.close();    
}


Instance 25

Class460.slurp(File file)#3{
                reader = new BufferedReader(
                        new InputStreamReader(new GZIPInputStream(new FileInputStream(file))), 1024);
            while ((c = reader.read()) != -1) {
                result.append((char)c);
            }
            reader.close();
}


Instance 26

Class500.loadFile(@Nonnull File logfile,@Nonnull Charset charset)#0{
        if(!logfile.exists())
            return "";
        StringBuilder str = new StringBuilder((int)logfile.length());
        BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(logfile),charset));
            while((len=r.read(buf,0,buf.length))>0)
               str.append(buf,0,len);
            r.close();
}


Instance 27

Class220.runAppFromCMD(PackageApp packageApp,String[] additionalArgs)#1{
            pb.redirectErrorStream(true);
            final Process process = pb.start();
            BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
            while ((c = input.read()) != -1) {
                System.out.print((char)c);
            }
            input.close();
}


Instance 28

Class610.findApplets(URL u)#0{
      inrdr = new BufferedReader(new InputStreamReader(u.openStream()));
      while ((i = inrdr.read()) != -1) {
        thisChar = (char)i;
        if (thisChar == '<') {
          String tag = readTag(inrdr);
          // System.out.println("TAG: " + tag);
          if (tag.toUpperCase().startsWith("<APPLET"))
            list.add(tag);
        }
      }
      inrdr.close();
}


Instance 29

Class40.run()#1{
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
              while((truc=reader.read())!=-1){
                if(truc!=10){
                  str+=(char)truc;
                }else{
                  ent.command(str, bwriter);
                  str="";
                }
              }
              reader.close();
}


Instance 30

Class250.readStreamAsString(InputStream in)#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    while ((numRead = reader.read(buf)) != -1)
      fileData.append(buf, 0, numRead);
    reader.close();
}


Instance 31

Class630.readAndClose(final HttpURLConnection connection)#0{
      reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      while ((bytesRead = reader.read(chars)) != -1) {
        builder.append(chars, 0, bytesRead);
      }
      if (reader != null) {
        reader.close();
      }
      if (connection != null) {
        connection.disconnect();
      }
}


Instance 32

Class580.readfile(String filename)#0{
    BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(filename), "KOI8-R"));
    while ((i = in.read(buf, 0, buf.length)) > -1) {
      if (i > 0) {
        out.append(buf, 0, i);
      }
    }
    in.close();
}


Instance 33

Class0.getText(String path)#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(
        getStream(path), LSystem.encoding));
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      sbr.append(readData.trim());
    }
    reader.close();
}


Instance 34

Class400.getTextSync(String path)#0{
      BufferedReader reader = new BufferedReader(new InputStreamReader(is));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
      }
      reader.close();
}


Instance 35

Class490.sanitizeXmlDocument(DefaultHandler handler,InputStream inputStream)#0{
                BufferedReader br = new BufferedReader(
                    new InputStreamReader(inputStream, Constants.DEFAULT_ENCODING));
                while ((read = br.read(buf)) != -1) {
                    listingDocBuffer.append(buf, 0, read);
                }
                br.close();
}


Instance 36

Class190.readFromPath(final String path,final String clientId,final String requestMethod)#0{
      final URL url = url(fullPath);
      connection = (HttpURLConnection) url.openConnection();
      connection.setRequestMethod(requestMethod);
      reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      while ((bytesRead = reader.read(chars)) != -1) {
        builder.append(chars, 0, bytesRead);
      }
      if (reader != null) {
        reader.close();
      }
      if (connection != null) {
        connection.disconnect();
      }
}


Instance 37

Class300.extractOutput(InputStream stream,XHTMLContentHandler xhtml){
      reader = new BufferedReader(new InputStreamReader(stream, IOUtils.UTF_8));
      while ((n = reader.read(buffer)) != -1) {
        if (n > 0) {
          xhtml.characters(buffer, 0, n);
        }
        totalBytes += n;
      }
      reader.close();
}


Instance 38

Class590.run()#0{
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        while((numRead = br.read(buf,0,256)) != -1) {
          sb.append(buf,0,numRead);
        }
        br.close();
}


Instance 39

Class380.doLargeReadSize(BaseClient client)#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(client.forRead(new Path(testFile1.getCanonicalPath()), 1024 * 1024)));
    while (reader.read() != -1) {
      count++;
    }
    reader.close();
}


Instance 40

Class250.getContent(InputStream inputStream,ByteArrayOutputStream outputStream){
      BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
      while ((readChar = reader.read()) != -1) {
        outputStream.write(readChar);
      }
      reader.close();
}


Instance 41

Class50.doSmallReadSize(BaseClient client)#0{
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(
            client.forRead(new Path(testFile1.getAbsolutePath()), 5)));
    while (reader.read() != -1) {
      count++;
    }
    reader.close();
}


Instance 42

Class80.changeEncoding(String sourceFilename,String targetFilename)#0{
      if ( Const.isEmpty( data.sourceEncoding ) ) {
        buffReader = new BufferedReader( new InputStreamReader( new FileInputStream( sourceFilename ) ) );
      } else {
        buffReader =
          new BufferedReader( new InputStreamReader( new FileInputStream( sourceFilename ), data.sourceEncoding ) );
      }
      while ( ( readSize = buffReader.read( cBuf ) ) != -1 ) {
        buffWriter.write( cBuf, 0, readSize );
      }
}


Instance 43

Class180.readFileAsString(String filePath)#0{
          BufferedReader reader = new BufferedReader(
                  new FileReader(filePath));
          while((numRead=reader.read(buf)) != -1){
              String readData = String.valueOf(buf, 0, numRead);
              fileData.append(readData);
              buf = new char[1024];
          }
          reader.close();
}


Instance 44

Class620.readFileAsString(String filePath)#0{
          BufferedReader reader = new BufferedReader(
                  new FileReader(filePath));
          while((numRead=reader.read(buf)) != -1){
      String readData = String.valueOf(buf, 0, numRead);
              fileData.append(readData);
          }
          reader.close();
}


Instance 45

Class260.readFile(File file)#0{
        BufferedReader reader = new BufferedReader(new FileReader(file));
        while((numRead=reader.read(buf)) != -1){
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[BUFFER_SIZE];
        }
        reader.close();
}


Instance 46

Class400.readFile(String file,PrintWriter errorWriter)#1{
                BufferedReader reader = new BufferedReader(new FileReader(f));
                while ((numRead = reader.read(buf)) != -1) {
                    String readData = String.valueOf(buf, 0, numRead);
                    fileData.append(readData);
                }
                reader.close();
}


Instance 47

Class230.readCert(String filePath)#0{
            BufferedReader reader = new BufferedReader(new FileReader(filePath));
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                fileData.append(readData);
                buf = new char[1024];
            }
            reader.close();
}


Instance 48

Class180.readFileAsString(String filePath)#0{
    BufferedReader reader = new BufferedReader(
        new FileReader(filePath));
    while((numRead=reader.read(buf)) != -1){
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 49

Class390.readFileAsString(String filePath)#1{
        BufferedReader reader = new BufferedReader(new FileReader(testResourceFile));
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
}


Instance 50

Class260.readFileAsString(File filePath)#0{
      reader = new BufferedReader(new FileReader(filePath));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
      }
      reader.close();
}


Instance 51

Class380.readFileAsString(File file)#0{
    BufferedReader reader = new BufferedReader(new FileReader(file));
    while ((numRead = reader.read(buf)) != -1) {
      fileData.append(buf, 0, numRead);
    }
    reader.close();
}


Instance 52

Class30.run()#1{
                reader = new BufferedReader(
                        new FileReader(jobFilePath));
                while((numRead=reader.read(buf)) > 0){
                    fileData.append(buf, 0, numRead);
                }
                reader.close();
}


Instance 53

Class510.receiveFile()#2{
    BufferedReader reader = new BufferedReader(new FileReader(output));
    while ((read = reader.read()) != -1)
      buffer.append((char) read);
    reader.close();
}


Instance 54

Class260.fileToString(File file)#0{
            BufferedReader reader = new BufferedReader(new InputStreamReader(new java.io.BufferedInputStream(fis)));
            while ((c = reader.read()) != -1) {
                sb.append((char) c);
            }
            fileText = sb.toString();
}


Instance 55

Class550.readURLConnection(URLConnection uc)#2{
      reader = new BufferedReader(new InputStreamReader(uc.getInputStream()));
      while ((letter = reader.read()) != -1)
        buffer.append((char) letter);
}


Instance 56

Class0.readFileAsString(String filePath)#0{
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
}


Instance 57

Class460.getFileAsString(File file)#0{
    BufferedReader reader = new BufferedReader(new FileReader(file));
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 58

Class110.loadFile()#0{
      BufferedReader reader = new BufferedReader(new FileReader(pathFile));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
      }
      reader.close();
}


Instance 59

Class50.readFileAsString(String filePath)#0{
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 60

Class260.readFileAsString(final String filePath)#0{
      final BufferedReader reader = new BufferedReader(new FileReader(filePath));
      while((length = reader.read(buf)) > -1){
    fileData.append(String.valueOf(buf, 0, length).replaceAll("_ExternalUrl_", ExternalUrl));
      }
      reader.close();
}


Instance 61

Class20.widgetSelected(final SelectionEvent e)#0{
                    reader = new BufferedReader(new FileReader(filename));
                    while ((numRead = reader.read(buf)) != -1) {
                        String readData = String.valueOf(buf, 0, numRead);
                        fileData.append(readData);
                        buf = new char[1024];
                    }
                    reader.close();
}


Instance 62

Class110.readFileAsString(File filePath)#0{
          BufferedReader reader = new BufferedReader(
                  new FileReader(filePath));
          while((numRead=reader.read(buf)) != -1){
              String readData = String.valueOf(buf, 0, numRead);
              fileData.append(readData);
              buf = new char[1024];
          }
          reader.close();
}


Instance 63

Class140.readFileContents(String filePath)#2{
      reader = new BufferedReader(new FileReader(filePath));
        while((numRead=reader.read(buf)) != -1){
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
}


Instance 64

Class320.readFileAsString(File filePath)#0{
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    while ((numRead = reader.read(buf)) != -1) {
      fileData.append(buf, 0, numRead);
    }
    reader.close();
}


Instance 65

Class500.readFileToString(String filePath)#0{
        BufferedReader reader = new BufferedReader(
                new FileReader(filePath));
        while ((numRead = reader.read(buf)) != -1) {
            fileData.append(buf, 0, numRead);
        }
        reader.close();
}


Instance 66

Class130.readStringFromFile(String pathFile)#0{
    BufferedReader reader = new BufferedReader(streamReader);
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 67

Class80.readerToString(Reader reader)#0{
    BufferedReader bufferedReader = new BufferedReader(reader);
      while ((numRead = bufferedReader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
      }
      bufferedReader.close();
}


Instance 68

Class470.readStringFromFile(String pathFile)#0{
    BufferedReader reader = new BufferedReader(streamReader);
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 69

Class480.readStringFromFile(InputStream stream)#0{
      BufferedReader reader = new BufferedReader(streamReader);
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
      }
      reader.close();
}


Instance 70

Class250.dumpWindowHierarchy(boolean compressed,String filename)#4{
                    reader = new BufferedReader(new FileReader(f));
                    while ((len = reader.read(buffer)) != -1) {
                        sb.append(new String(buffer, 0, len));
                    }
                    reader.close();
}


Instance 71

Class180.ReadFileToCharArray(String filePath)#1{
    BufferedReader reader = new BufferedReader(new FileReader(filePath));
    while ((numRead = reader.read(buf)) != -1) {
      String readData = String.valueOf(buf, 0, numRead);
      fileData.append(readData);
      buf = new char[1024];
    }
    reader.close();
}


Instance 72

Class540.readFileAsString(File f)#0{
        BufferedReader reader = new BufferedReader(
                new FileReader(f));
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
}


Instance 73

Class650.read(InputStream stream)#1{
      BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
    while( reader.read(buffer) >= 0 ) {
      requestBody.append( buffer.flip() );
      buffer.clear();
    }
}


Instance 74

Class290.loadAddress(final String interfaceName)#0{
            final BufferedReader reader = new BufferedReader(new FileReader(filePath), 1024);
            while ((numRead = reader.read(buf)) != -1) {
                readData = String.valueOf(buf, 0, numRead);
                fileData.append(readData);
            }
            reader.close();
}


Instance 75

Class250.readString(InputStream is,String encoding)#0{
      reader= new BufferedReader(new InputStreamReader(is, encoding));
      while ((read= reader.read(part)) != -1)
        buffer.append(part, 0, read);
      return buffer.toString();
}


Instance 76

Class210.openBuffer(IProgressMonitor pm)#2{
          BufferedReader stream = new BufferedReader(new InputStreamReader(bin.getContents()));
          while ((len = stream.read(buf, 0, buf.length)) != -1) {
            sb.append(buf, 0, len);
          }
}


Instance 77

Class420.loadTextFile(File file)#0{
    BufferedReader reader = new BufferedReader(new FileReader(file));
      while ((len = reader.read(buffer)) != -1) {
        input.append(buffer, 0, len);
      }
      reader.close();
}


Instance 78

Class260.readFileAsString(File file)#1{
    BufferedReader reader = new BufferedReader(new FileReader(file));
    while ((numRead = reader.read(buf)) != -1)
    {
      sb.append(buf, 0, numRead);
    }
    reader.close();
}


Instance 79

Class290.readFileAsString(File file)#0{
        BufferedReader reader = new BufferedReader(new FileReader(file));
        while((numRead=reader.read(buf)) != -1){
            fileData.append(buf, 0, numRead);
        }
        reader.close();
}


Instance 80

Class370.readTextFile(File file)#0{
            BufferedReader reader = new BufferedReader(new FileReader(file));
            while(-1 != (bytes = reader.read(buf)))
                fileData.append(buf, 0, bytes);
            reader.close();
}


Instance 81

Class170.read(String fileName)#1{
    FileReader reader = new FileReader(fileName);
    BufferedReader b = new BufferedReader(reader);
    while ((n = b.read(buffer, 0, buffer.length)) != -1) 
      builder.append(buffer, 0, n);
    b.close();
}


Instance 82

Class460.activate(IokeObject method,IokeObject context,IokeObject message,Object on)#0{
                        BufferedReader reader = new BufferedReader(new FileReader(f));
                        while((read = reader.read(buf, 0, 1024)) != -1) {
                            sb.append(buf, 0, read);
                        }
                        reader.close();
}


Instance 83

Class220.read(InputStream stream)#0{
      BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
    while( reader.read(buffer) >= 0 ) {
      requestBody.append( buffer.flip() );
      buffer.clear();
    }
}


Instance 84

Class590.main(String args[])#4{
        final BufferedReader reader = new BufferedReader( new FileReader(configFile));
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            sb.append(readData);
        }
        reader.close();
}


Instance 85

Class350.readFileAsString(String filePath)#0{
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
}


Instance 86

Class390.readString(InputStream is,String encoding)#0{
            reader = new BufferedReader(new InputStreamReader(is, encoding));
            while ((read= reader.read(part)) != -1) {
                buffer.append(part, 0, read);
            }
            return buffer.toString();
}


Instance 87

Class140.readString(InputStream is,String encoding)#1{
      reader= new BufferedReader(new InputStreamReader(is, encoding));
      while ((read= reader.read(part)) != -1)
        buffer.append(part, 0, read);
      return buffer.toString();
}


Instance 88

Class340.readContent(IFile file)#0{
      reader = new BufferedReader(new InputStreamReader(is, encoding));
      while ((read = reader.read(part)) != -1) {
        buffer.append(part, 0, read);
      }
      return buffer.toString();
}


Instance 89

Class40.readString(InputStream inputStream,String encoding)#0{
      reader = new BufferedReader(new InputStreamReader(inputStream, encoding));
      while ((read = reader.read(part)) != -1)
        buffer.append(part, 0, read);
      return buffer.toString();
}


Instance 90

Class310.readString(InputStream is,String encoding)#1{
      reader= new BufferedReader(new InputStreamReader(is, encoding));
      while ((read= reader.read(part)) != -1)
        buffer.append(part, 0, read);
      return buffer.toString();
}


Instance 91

Class20.readString(final InputStream is,final String encoding)#1{
            reader = new BufferedReader(new InputStreamReader(is, encoding));
            while ((read = reader.read(part)) != -1) {
                buffer.append(part, 0, read);
            }
            return buffer.toString();
}


Instance 92

Class210.updateDatabase(Connection c,String pathToSQLFile)#3{
      FileReader fr = new FileReader(new File(pathToSQLFile));
      BufferedReader br = new BufferedReader(fr);
      while ((s = br.read()) != -1) {
        sb.appendCodePoint(s);
      }
      br.close();
}


Instance 93

Class420.readErrorStreamFully(InputStream is,BluetoothProcessListener listener)#1{
    br = new BufferedReader(new InputStreamReader(is));
    while ((ch = br.read()) != -1) {
      stringBuilder.append((char) ch);
    }
    listener.processErrorStream(stringBuilder.toString());
}


Instance 94

Class0.copyWifiSupplicantTemplate(BufferedWriter bw)#0{
            BufferedReader br = new BufferedReader(new FileReader(FILE_WIFI_SUPPLICANT_TEMPLATE));
            while ((size = br.read(temp)) > 0) {
                bw.write(temp, 0, size);
            }
            br.close();
}


Instance 95

Class80.getFileAsBytes(File file)#1{
    BufferedReader br = new BufferedReader(new FileReader(file));
    while((b = br.read()) != -1) {
      bytes[i] = (byte)b;
      i++;
    }
    br.close();
}


Instance 96

Class110.readFile(final File file)#0{
        final BufferedReader input = new BufferedReader(new FileReader(file));
            while (input.read(c) > 0) {
                /*
                 * char[] chars = line.toCharArray(); for (int i = 0; i <
                 * chars.length; ++i) { result.add(chars[i]); }
                 * result.add('\n'); } input.close(); if (result.size() != 0) {
                 * result.remove(result.size() - 1);
                 */
                result.add(c[0]);
            }
            input.close();
}


Instance 97

Class350.doGet(String urlSite)#0{
      url = new URL(urlSite);
      urlConn = url.openConnection();
      urlConn.addRequestProperty("User-Agent",
          "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)");
      Reader reader = new InputStreamReader(urlConn.getInputStream(),
          "utf-8");
      BufferedReader br = new BufferedReader(reader);
      while ((byteRead = br.read()) != -1)
        result.append((char) byteRead);
}


Instance 98

Class620.httpGet(String url,int timeout)#2{
            reader = new BufferedReader(new InputStreamReader(inputStream));
            while ((c = reader.read()) != -1) {
                responseBuf.append((char) c);
            }
            return responseBuf.toString();
}


Instance 99

Class350.download_apk(Activity act)#0{
      u = new URL("http://undroid.net/repo/packages/Note_Pad.apk");
      in = new BufferedReader(new InputStreamReader(u.openStream()));
      while ((buf = in.read()) >= 0) {
        out.write((char) buf);
      }
      out.flush();
      out.close();
}


Instance 100

Class300.main(String[] argv){
    BufferedReader is = new BufferedReader(
      new InputStreamReader(System.in));
    while ((c=is.read()) != -1) {
      System.out.print((char)c);
    }
}


Instance 101

Class390.dumpStream(InputStream stream)#1{
            new BufferedReader(new InputStreamReader(stream));
            while ((i = in.read()) != -1) {
                   MessageOutput.printDirect((char)i);// Special case: use
                                                      //   printDirect()
            }
}


Instance 102

Class510.writeBinaryStream(java.io.InputStream x)#0{
         BufferedReader bufReader = new BufferedReader(new InputStreamReader(x));
             while( (i=bufReader.read()) != -1 ) {
                char ch = (char)i;

                StringBuffer strBuf = new StringBuffer();
                strBuf.append(ch);

                String str = new String(strBuf);
                String strLine = bufReader.readLine();

                writeString(str.concat(strLine));
             }
}


Instance 103

Class330.updated(UpdateEvent e)#2{
            BufferedReader reader = new BufferedReader(new FileReader(monitor.file));
            while ((len = reader.read(chars)) > -1)
              sb.append(chars,0,len);
            reader.close();
}


Instance 104

Class610.readEnclosingLine(String filename,int start,int end)#1{
      BufferedReader in = new BufferedReader(new InputStreamReader(
          new FileInputStream(filename), "UTF-8"));
      while ((len = in.read(buf)) != -1) {
        text.append(buf, 0, len);
      }
      while (lineEnd < text.length() && lineEnd <= start) {
        lineStart = lineEnd;
        lineEnd = parseLine(text, lineEnd);
        line = line + 1;
      }
}


Instance 105

Class400.agreementContents()#5{
      String filename = "terms_" + SystemGlobals.getValue(ConfigKeys.I18N_DEFAULT) + ".txt";
      File file = new File(directory + filename);
      if (!file.exists()) {
        filename = SystemGlobals.getValue(ConfigKeys.AGREEMENT_DEFAULT_FILE);
        file = new File(directory + filename);
        
        if (!file.exists()) {
          throw new FileNotFoundException("Could not locate any terms agreement file");
        }
      }
      fileReader = new FileReader(file);
      reader = new BufferedReader(fileReader);
      while ((c = reader.read(buffer, 0, buffer.length)) > -1) {
        contents.append(buffer, 0, c);
      }
}


Instance 106

Class500.getResourceAsString(Class c,String resource)#1{
            in = c.getClassLoader().getResourceAsStream(resource);
            reader = new BufferedReader(new InputStreamReader(in));
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                sb.append(readData);
                buf = new char[BUFFER_SIZE];
            }
            safeClose(in);
}


Instance 107

Class520.readIntoString(InputStream s)#0{
        BufferedReader rdr = new BufferedReader(new InputStreamReader(s));
            while ((cnt = rdr.read(buffer, 0, buffer.length)) != -1) {
                bld.append(buffer, 0, cnt);
            }
            return bld.toString();
}


Instance 108

Class290.loadRawTextResourceAsString(Context context,int resourceId)#0{
      reader = new BufferedReader(new InputStreamReader(context.getResources().openRawResource(resourceId)));
      while ((count = reader.read(buf, 0, READ_BUF_LEN)) != -1) {
        builder.append(buf, 0, count);
      }
      return builder.toString();
}


Instance 109

Class520.getContent(HttpResponse response)#3{
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            while ((read = reader.read(buff)) != -1) {
                builder.append(buff, 0, read);
            }
            return builder.toString();
}


Instance 110

Class470.setupScriptConfig()#1{
                    BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"), 1024);
                    while ((read=reader.read(buf)) != -1)
                    {
                        fileContents.append(buf, 0, read);
                    }
                    this.xmlConfig = fileContents.toString();
}


Instance 111

Class410.readString(final InputStream is)#0{
            reader = new BufferedReader(new InputStreamReader(is));
            while ((read = reader.read(part)) != -1) {
                buffer.append(part, 0, read);
            }
            return buffer.toString();
}


Instance 112

Class30.loadTextAssetAsString(Context context,String path)#0{
      reader = new BufferedReader(new InputStreamReader(assetManager.open(path)));
      while ((count = reader.read(buf, 0, READ_BUF_LEN)) != -1) {
        builder.append(buf, 0, count);
      }
      return builder.toString();
}


Instance 113

Class40.getBody(HttpServletRequest request)#0{
          InputStream inputStream = request.getInputStream();
          if (inputStream != null) {
              bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
              char[] charBuffer = new char[128];
              int bytesRead = -1;
              while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                  stringBuilder.append(charBuffer, 0, bytesRead);
              }
          } else {
              stringBuilder.append("");
          }
}


Instance 114

Class430.run(){
          BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()), 1);
            while ((c = reader.read()) != -1) {
              callback.character((char)c);            
            }
}


Instance 115

Class490.setAppInfoFromRawRes()#2{
                 in = getResources().openRawResource(R.raw.introduction);
                if (in != null) {
                    InputStreamReader isr = new InputStreamReader(in);
                    BufferedReader br = new BufferedReader(isr);
                    char [] buf = new char[1024];
                    int len = 0;
                    while ((len = br.read(buf)) > 0) {
                        sb.append(buf, 0, len);
                    }
                } else {
                    Log.e(TAG, "Read introduction file error");
                    return;
                }
}


Instance 116

Class210.readResource(String name)#3{
      BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
      while ((read = reader.read(buffer)) != -1) {
        stringBuilder.append(buffer, 0, read);
      }
      inputStream.close();
}


Instance 117

Class240.readProcessStdout()#1{
         new BufferedInputStream(p.getInputStream());
         new BufferedReader(new InputStreamReader(stdoutStream));
      while((nc = stdoutRead.read(c,0,100)) != -1)
      {
        chunk  = new String(c,0,nc);
        stdout = stdout.append(chunk);
      }
}


Instance 118

Class560.transferData(Reader source,int tz)#1{
        BufferedReader in = new BufferedReader(source);
        while ((read = in.read(bridge, 0, tz)) != -1) {
            this.clob.setString(total +1L, String.copyValueOf(bridge, 0, read));
            total += read;
        }
        in.close();
}


Instance 119

Class90.read(InputStream in)#0{
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
      while ((read = bufferedReader.read(buffer, 0, buffer.length)) > 0) {
        stringBuilder.append(buffer, 0, read);
      }
      return stringBuilder.toString();
}


Instance 120

Class400.readProcessStderr()#1{
         new BufferedInputStream(p.getErrorStream());
         new BufferedReader(new InputStreamReader(stderrStream));
      while((nc = stderrRead.read(c,0,100)) != -1)
        stderr = stderr.append(new String(c,0,nc));
}


Instance 121

Class410.doInBackground(String... params)#0{
                                BufferedReader in = new BufferedReader(new InputStreamReader(conn
                                        .getInputStream()));
                                while ((len = in.read(buf)) != -1) {
                                    obj.append(buf, 0, len);
                                }
                                res.putExtra(DB.ACCOUNT.AUTH_CONFIG, obj.toString());
}


Instance 122

Class50.getContentFromInputStream()#1{
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(inputStream, charSet));
    while ((charsRead = reader.read(chunk, 0, BUF_SIZE)) > 0) {
      sb.append(chunk, 0, charsRead);
    }
    return sb.toString();
}


Instance 123

Class420.readFile(String input)#0{
      fr = new InputStreamReader(new FileInputStream(input), ENCODING);
      br = new BufferedReader(fr);
      while ((len = br.read(buffer)) > -1) {
        content.append(buffer, 0, len);
      }
}


Instance 124

Class170.InMessage(HttpServletRequest request)#0{
      requestBodyReader = new BufferedReader(new InputStreamReader(
          request.getInputStream()));
      while (requestBodyReader.read(buffer) >= 0) {
        requestBody.append(buffer.flip());
        buffer.clear();
      }
}


Instance 125

Class610.computeLineNumber()#0{
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(txtFile), encoding));
      while ((ch = reader.read()) != -1) {
        if (ch == '\r' || ch == '\n') {
          if (!isline) {
            isline = true;
            count++;
          }
        } else {
          isline = false;
        }
      }
}


Instance 126

Class270.run()#0{
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);
      while ((read = br.read(cbuf)) != -1) {
        //System.out.println(type + ">number of bytes read: " + read);
        
        if (count < MAX_BYTES) {
          count += read; // might slightly exceed MAX_BYTES
          sb.append(cbuf, 0, read);
        }
      }
}


Instance 127

Class110.getResourceAsString(String resourceName)#0{
            InputStream in = Resource.class.getResourceAsStream(resourceName);
            if (in == null) {
                return null;
            }
            reader = new BufferedReader(new InputStreamReader(in, ENCODING_UTF8));
            while (-1 != (n = reader.read(buffer))) {
                writer.write(buffer, 0, n);
            }
            writer.flush();
            return writer.toString();
}


Instance 128

Class190.assertFileContents(String expected,File file)#1{
            reader = new BufferedReader(new FileReader(file));
            while (-1 != (howMany = reader.read(buffer))) {
                contents.append(buffer, 0, howMany);
            }
            assertEquals("checking file contents for " + file,
                         expected,
                         contents.toString());
}


Instance 129

Class360.process()#1{
            reader = new BufferedReader(
                new InputStreamReader(resourceLoader.getResourceStream(name),
                                      encoding));
            while ( ( len = reader.read( buf, 0, 1024 )) != -1)
                sw.write( buf, 0, len );
            setData(sw.toString());
}


Instance 130

Class320.readStream(InputStream inputStream){
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            int length = reader.read(buffer);
            assertTrue("Failed to read anything from input stream", length > -1);
            return String.valueOf(buffer, 0, length);
            reader.close();
}


Instance 131

Class200.findString(String filePath,String stringToFind)#0{
        BufferedReader in = new BufferedReader(new FileReader(filePath));
            while ((numread = in.read(data, 0, 8096)) != -1) {
                for (int i = 0; i < numread; i++) {
                    /* If we have found the string already or if we our current
                     * character matches the current char in the target string
                     * then we just add the current character to our result
                     * string and move on.
                     */
                    if (toFindIndex >= stringToFind.length() || data[i] == stringToFind.charAt(toFindIndex)) {
                        if (result == null) {
                            result = new StringBuilder();
                        }
                        if (Character.isISOControl(data[i])) {
                            return result.toString();
                        }
                        result.append(data[i]);
                        toFindIndex++;
                    } else {
                        /* Otherwise things can get complex.  If we haven't
                         * started to match, then just keep going.  If we have
                         * started to match, then we need to move backwards
                         * to make sure we don't miss a match.  For example:
                         * looking for HI in HHI.  If the current character
                         * isn't the same as the last character, then we aren't
                         * going to match, so null everything out and keep
                         * going.  Otherwise, decrment everything by one,
                         * because we didn't match the first character, and
                         * go through the loop on this character again.
                         */
                        if (toFindIndex > 0) {
                            if (data[i] != lastchar) {
                                result = null;
                                toFindIndex = 0;
                                continue;
                            }
                            toFindIndex--;
                            i--;
                            result.deleteCharAt(result.length() - 1);
                            continue;
                        }
                    }
                    lastchar = data[i];
                }
            }
}


Instance 132

Class280.readFileAsString(String fpath)#1{
    BufferedReader reader = new BufferedReader(new FileReader(new File(fpath)));
    while ((numRead=reader.read(buff)) != -1) {
      String readData = String.valueOf(buff, 0, numRead);
      sb.append( readData );
    }
    return sb.toString();
}


Instance 133

Class560.doUpdateModhash(HttpClient client)#6{
        HttpGet httpget = new HttpGet(Constants.MODHASH_URL);
        HttpResponse response = client.execute(httpget);
          entity = response.getEntity();
          BufferedReader in = new BufferedReader(new InputStreamReader(entity.getContent()));
          in.read(buffer, 0, 1200);
          in.close();
}


Instance 134

Class620.readTextFile(File file)#1{
    BufferedReader reader = new BufferedReader(new FileReader(file));
      while ((numRead = reader.read(buf)) != -1) {
        String readData = String.valueOf(buf, 0, numRead);
        fileData.append(readData);
        buf = new char[1024];
      }
      IOUtils.cleanup(null, reader);
}


Instance 135

Class480.readReaderContents(Reader r)#1{
            reader= new BufferedReader(r);
            while ((read= reader.read(part)) != -1)
                buffer.append(part, 0, read);
            return buffer.toString();
}


Instance 136

Class300.readString(InputStream inputStream,final int size)#3{
            reader = new BufferedReader(new InputStreamReader(inputStream));
            reader.read(buffer);
            reader.close();
}


Instance 137

Class580.run(IAction action)#6{
      URL url = Platform.find(bundle, new Path("samples/manifest.txt")); //$NON-NLS-1$
      url = Platform.resolve(url);
      Object content = url.getContent();
      InputStream ins = (InputStream) content;
      int count = ins.available();
      BufferedReader in = new BufferedReader(new InputStreamReader(ins));
      in.read(cbuf);
      in.close();
}


Instance 138

Class440.copy_apk(Activity act,String _sourceDir,String packageName)#0{
      in = new BufferedReader(new FileReader(_sourceDir));
      while ((buf = in.read()) >= 0) {
        out.write((char) buf);
      }
      out.flush();
      out.close();
}


Instance 139

Class310.execute(final String cmd)#0{
            reader = new BufferedReader(new FileReader(file));
            while ((numRead = reader.read(buf)) != -1) {
                String readData = String.valueOf(buf, 0, numRead);
                builder.append(readData);
                buf = new char[1024];
            }
}


Instance 140

Class610.buildDocument()#2{
      doc.add(new TextField("path", _file.getAbsolutePath(), Store.YES));
        freader = new FileReader(_file);
        BufferedReader br = new BufferedReader(freader);
        int len = br.read(cb, 0, cb.length);
        while (end < len) {
          if (cb[end] == '\n' || cb[end] == '\r') {
            sb.append(cb, start, end - start).append('\n');
            start = end;
            while (start < len && (cb[start] == '\n' || cb[start] == '\r')) {
              start++;
            }
            end = start;
          }
          end++;
        }
}


Instance 141

Class0.readFile(File f)#0{
    BufferedReader in = new BufferedReader(new FileReader(f));
    for(int c; (c = in.read()) != -1; b.append((char)c));
    in.close();      
}


Instance 142

Class340.getTestFileContent(String file)#3{
            reader = new BufferedReader(new FileReader(testFile));
            while ((numRead = reader.read(buf)) != -1) {
                stringWriter.write(buf, 0, numRead);
            }
            result = stringWriter.toString();
}


Instance 143

Class140.getReaderAsString(Reader r)#0{
      reader = new BufferedReader(r);
      while ((charsRead = reader.read(buf)) != -1) {
        text.append(buf, 0, charsRead);
      }
      return text.toString();
}


Instance 144

Class330.loadOvfContents(String ovfPath){
         File ovfFile = new File(ovfPath);
         reader = new BufferedReader(new FileReader(ovfFile));
         AuAssert.check(ovfFile.length() < MAX_OVF_SIZE);
         int totalLen = (int)(ovfFile.length() < MAX_OVF_SIZE ?
                              ovfFile.length() : MAX_OVF_SIZE);
         while (offset < totalLen &&
                (len = reader.read(ovfBuf, offset, totalLen - offset)) != -1) {
            offset += len;
         }
         if (reader != null) {
            reader.close();
         }
      return new String(ovfBuf);
}


Instance 145

Class430.readContent(GetMethod get)#0{
            Reader input = new InputStreamReader(get.getResponseBodyAsStream(), get.getResponseCharSet());
            BufferedReader bufferedReader = (input instanceof BufferedReader) ? (BufferedReader) input
                : new BufferedReader(input);
            while ((charsRead = bufferedReader.read(buffer)) != -1) {
                result.append(buffer, 0, charsRead);
            }
            result.append(get.getResponseBodyAsString());
        return result.toString();
}


Instance 146

Class440.readContent(InputStream input)#1{
        reader = new BufferedReader(isr);
        while ((charsRead = reader.read(charBuff)) > -1) {
          strBuff.append(charBuff, 0, charsRead);
        }
        CodeGenUtil.closeQuietly(reader);
}


Instance 147

Class540.readFileFromClassPath(String filename)#0{
      BufferedReader br = new BufferedReader(new InputStreamReader(
          Export.class.getClassLoader().getResourceAsStream(filename)));
      for (int c = br.read(); c != -1; c = br.read()) 
        sb.append((char)c);
}


Instance 148

Class90.writeCharacterStream(java.io.Reader x)#1{
         BufferedReader bufReader = new BufferedReader(x);
             while( (i = bufReader.read()) != -1 ) {
                char ch = (char)i;
                StringBuffer strBuf = new StringBuffer();
                strBuf.append(ch);

                String str = new String(strBuf);
                String strLine = bufReader.readLine();

                writeString(str.concat(strLine));
             }
}


Instance 149

Class410.readFileFromClasspath(String fileName)#1{
        br = new BufferedReader(new InputStreamReader(new ClassPathResource(fileName).getInputStream(), "UTF-8"));
        for (int c = br.read(); c != -1; c = br.read()) {
            sb.append((char) c);
        }
        return sb.toString();
}


Instance 150

Class10.readString(InputStream stream)#0{
      BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
      for (int ch = reader.read(); ch >= 0; ch = reader.read()) {
        buf.append((char) ch);
      }
      return buf.toString();
}


Instance 151

Class470.getReaderAsString(Reader reader)#0{
    BufferedReader in = new BufferedReader(reader);
    while ((n = in.read(buf)) > 0) {
      sw.write(buf, 0, n);
    }
    return sw.toString();
}


Instance 152

Class230.toString(InputStream is)#0{
            br = new BufferedReader(new InputStreamReader(is, charSet));
            for (int read; (read = br.read(buf)) != -1; ) {
                result.append(buf, 0, read);
            }
            return result.toString();
}


Instance 153

Class520.loadLevel()#0{
      FileReader fstream = new FileReader("save.dat");
      BufferedReader in = new BufferedReader(fstream);
      int deadCounter = in.read();
      in.close();
      result[1] = Integer.valueOf(deadCounter);
}


Instance 154

Class50.run()#0{
    logger.debug("Loading file into styled text (" + f.getAbsolutePath() + ")");
      BufferedReader in = new BufferedReader(new FileReader(f));
      while(in.ready()){
        in.read(buf);
        file = file + new String(buf);
      }
      styledText.setText(file);
}


Instance 155

Class270.loadTipFile(String tipsFilePath)#0{
    final File tipsFile = new File(tipsFilePath);
    final BufferedReader tipsReader = new BufferedReader(new InputStreamReader(new FileInputStream(tipsFile),
        "UTF-8"));
    final int length = (int) tipsFile.length();
    tipsReader.read(inputLine, 0, length);
    tipsReader.close();
}


Instance 156

Class200.fillsBuffer()#0{
        for (int i = 0; i < 1000; ++i) {
            sb.append((char)i);
        }
        BufferedReader reader = new BufferedReader(new StringReader(sb.toString()), 101);
        reader.read(buffer);
        assertEquals(499, buffer[499]);
}


Instance 157

Class560.loadPlotData(TownBlock townBlock)#1{
        BufferedReader fin = new BufferedReader(new FileReader(fileName));
          fin.read(key,0,3);
          String test = new String(key);
          switch (elements.fromString(test)) {
          case VER:
            // Read the file version
            int version = fin.read();
            plotBlockData.setVersion(version);
            
            // next entry is the plot height
            plotBlockData.setHeight(fin.read());
            break;
            
          default:
            /*
             * no version field so set height
             * and push rest to queue
             * 
             */
            plotBlockData.setVersion(0);
            // First entry is the plot height
            plotBlockData.setHeight(key[0]);
            IntArr.add((int) key[1]);
            IntArr.add((int) key[2]);
          }
}


Instance 158

Class240.readFile(String filename)#1{
    BufferedReader in = new BufferedReader(new FileReader(f));
    in.read(readIn);
    readString = new String(readIn);
}


Instance 159

Class580.fileToChars(char[] p,String fileName)#0{
      FileReader fr = new FileReader(fileName);
      BufferedReader br = new BufferedR
}


Instance 160

Class390.run()#0{
        BufferedReader bufferedReader = new BufferedReader(reader);
        for (readResult = bufferedReader.read(buffer);readResult>=0;readResult = bufferedReader.read(buffer))
        {
          processOutputStreamWriter.write(buffer, 0, readResult);
        }
        processOutputStreamWriter.close();
}


Instance 161

Class170.test_readLine_interaction_with_array_read_1(){
        BufferedReader r = new BufferedReader(new StringReader("1\r\n2"));
        assertEquals(2, r.read(new char[2], 0, 2));
        assertEquals("", r.readLine()); // The '\r' we read() didn't count.
        assertEquals("2", r.readLine());
        assertNull(r.readLine());
}


Instance 162

Class280.test_read()#4{
        assertTrue(new BufferedReader(new CharArrayReader(new char[5], 1, 0), 2).read() == -1);
}


Instance 163

Class140.test_read$CII_Exception()#0{
            new BufferedReader(new PipedReader(), 9).read(new char[] {}, 7, 0);
}


Instance 164

Class160.Read(File file,String encoding)#1{
            BufferedReader in = new BufferedReader(new FileReader(file));
            char[] allChars = new char[(int) file.length()];
            in.read(allChars, 0, (int) file.length());
            in.close();
}


Instance 165

Class540.parseFile(String file,String encoding)#2{
    File path = new File(file);
    FileInputStream in = new FileInputStream(path);
    InputStreamReader inr = new InputStreamReader(in, encoding);
    BufferedReader bfr = new BufferedReader(inr);
    char[] doc = new char[(int) path.length()];
    bfr.read(doc);
}


Instance 166

Class530.testProxyWhiteList()#3{
            SimpleHttpResponse response = readResponse(input);
            Assert.assertEquals("403", response.getCode());
            Assert.assertEquals(-1, input.read());
            OutputStream output = socket.getOutputStream();
            BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
}


Instance 167

Class320.testOpenRequestClose()#1{
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        SimpleHttpResponse response = httpParser.readResponse(reader);
        Assert.assertEquals("200", response.getCode());
        Assert.assertEquals(-1, reader.read());
        socket.close();
}


Instance 168

Class510.testSSLOpenRequestClose()#9{
        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        SimpleHttpResponse response = httpParser.readResponse(reader);
        Assert.assertEquals("200", response.getCode());
        Assert.assertEquals(-1, reader.read());
        socket.close();
}


Instance 169

Class10.testClientRequestStallsContentProxyIdlesTimeout()#0{
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
            SimpleHttpResponse response = parser.readResponse(reader);
            Assert.assertTrue(Integer.parseInt(response.getCode()) >= 500);
            String connectionHeader = response.getHeaders().get("connection");
            Assert.assertNotNull(connectionHeader);
            Assert.assertTrue(connectionHeader.contains("close"));
            Assert.assertEquals(-1, reader.read());
}


Instance 170

Class160.leavesMark()#0{
        for (int i = 0; i < 1000; ++i) {
            sb.append((char)i);
        }
        BufferedReader reader = new BufferedReader(new StringReader(sb.toString()), 100);
        reader.skip(50);
        reader.mark(70);
        reader.skip(60);
        reader.reset();
        int charsRead = reader.read(buffer);
        assertEquals(199, buffer[149]);
}


Instance 171

Class470.testSplitMultiLine(){
        BufferedReader br = new BufferedReader(new StringReader(line));
        out = CSVSaveService.csvReadFile(br, ',');
        checkStrings(new String[]{"a","","c\nd","e"}, out);
        out = CSVSaveService.csvReadFile(br, ',');
        checkStrings(new String[]{"","","f","g",""}, out);
        out = CSVSaveService.csvReadFile(br, ',');
        checkStrings(new String[]{""}, out); // Blank line
        assertEquals("Expected to be at EOF",-1,br.read());
        out = CSVSaveService.csvReadFile(br, ',');
        checkStrings(new String[]{}, out);
        out = CSVSaveService.csvReadFile(br, ',');
        checkStrings(new String[]{}, out);
}


Instance 172

Class590.testSchema()#1{
        for (int ch; (ch = in.read()) != -1;)
            buf.append((char) ch);
        in.close();
}


Instance 173

Class80.read(InputStream in)#0{
        for (int n; (n = reader.read(c)) != -1;) {
            out.append(new String(c, 0, n));
        }
        reader.close();
}


Instance 174

Class560.newBufferedReader()#0{
        final CharBuffer buffer = CharBuffer.allocate(contents.length());
        reader.read(buffer);
        reader.close();
}


Instance 175

Class460.newBufferedReader()#3{
        reader.close();
            reader.read();
}


Instance 176

Class150.pipe(BufferedReader br)#0{
    StringBuffer sb = new StringBuffer (BUFSIZE);
    do {
      count = br.read (buf, 0, BUFSIZE);
      sb.append (buf);
    } while (count == BUFSIZE);
    lexer.setCharSequence ((CharSequence)sb);
}